home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / dev / lang / bcpl4amiga.lha / bcpl / interp.cware.c < prev    next >
C/C++ Source or Header  |  1991-02-04  |  5KB  |  347 lines
  1. #include    "icint.h"
  2.  
  3. int interpret()
  4. {
  5. #ifdef    cware
  6.     static int    a, b, c, d, w, p;
  7.     static word    *wp;
  8. #else
  9.     register int    a, b, c, d, w, p;
  10.     register word    *wp;
  11. #endif
  12. #ifdef    unix
  13.     register word    *rmem = mem;
  14. #define    mem    rmem
  15. #endif
  16.  
  17.     p = pp;
  18.     c = progvec;
  19.     cyclecount = 0;
  20. fetch:
  21.     cyclecount++;
  22. #ifndef    cware
  23.     w = mem[c++];
  24.  
  25.     if (w & DBIT)
  26.         d = mem[c++];
  27.     else
  28.         d = w & ABITS;
  29.  
  30. #ifdef    DEBUG
  31.     fprintf(stderr, "%04x: %04x %05d\n", c - progvec - 1, w, d);
  32. #endif    DEBUG
  33.  
  34.     if (w & PBIT)
  35.         d += p;
  36.     if (w & GBIT)
  37.         d += gp;
  38.     if (w & IBIT)
  39.         d = mem[d];
  40.  
  41. #ifdef    profiling
  42.     ++majinstr[(w >> FSHIFT) & 07];
  43. #endif
  44.  
  45.     switch ((w >> FSHIFT) & 07)
  46. #else
  47. #asm
  48.  MOV SI,WORD interpret_c_
  49.  INC WORD interpret_c_
  50.  SHL SI,1
  51.  ADD SI,WORD mem_
  52.  MOV AX,WORD [SI]
  53.  OR AX,AX
  54.  JGE _L1_
  55.  INC WORD interpret_c_
  56.  ADD SI,2
  57.  MOV DI,WORD [SI]
  58.  JMP _L2_
  59. _L1_:
  60.  MOV BH,0
  61.  MOV BL,AL
  62.  MOV DI,BX
  63. _L2_:
  64.  MOV AL,AH
  65.  ROR AX,1
  66.  JNC _L3_
  67.  ADD DI,WORD interpret_p_
  68. _L3_:
  69.  ROR AX,1
  70.  JNC _L4_
  71.  ADD DI,WORD gp_
  72. _L4_:
  73.  ROR AX,1
  74.  JNC _L5_
  75.  SHL DI,1
  76.  ADD DI,WORD mem_
  77.  MOV DI,WORD [DI]
  78. _L5_:
  79.  MOV WORD interpret_d_,DI
  80.  AND AX,14
  81.  MOV BX,AX
  82.  JMP BYTE _L6_[BX]
  83. _L6_:
  84.  DW OP_L
  85.  DW OP_S
  86.  DW OP_A
  87.  DW OP_J
  88.  DW OP_T
  89.  DW OP_F
  90.  DW OP_K
  91.  DW OP_X
  92. #
  93. #endif
  94.     {
  95. #ifndef    cware
  96.     case OP_L:
  97. #else
  98. #asm
  99. OP_L:
  100. #
  101. #endif
  102.         b = a;
  103.         a = d;
  104.         goto fetch;
  105.  
  106. #ifndef    cware
  107.     case OP_S:
  108. #else
  109. #asm
  110. OP_S:
  111. #
  112. #endif
  113.         mem[d] = a;
  114.         goto fetch;
  115.  
  116. #ifndef    cware
  117.     case OP_A:
  118. #else
  119. #asm
  120. OP_A:
  121. #
  122. #endif
  123.         a += d;
  124.         goto fetch;
  125.  
  126. #ifndef    cware
  127.     case OP_J:
  128. #else
  129. #asm
  130. OP_J:
  131. #
  132. #endif
  133.         c = d;
  134.         goto fetch;
  135.  
  136. #ifndef    cware
  137.     case OP_T:
  138. #else
  139. #asm
  140. OP_T:
  141. #
  142. #endif
  143.         if (a)
  144.             c = d;
  145.         goto fetch;
  146.  
  147. #ifndef    cware
  148.     case OP_F:
  149. #else
  150. #asm
  151. OP_F:
  152. #
  153. #endif
  154.         if (!a)
  155.             c = d;
  156.         goto fetch;
  157.  
  158. #ifndef    cware
  159.     case OP_K:
  160. #else
  161. #asm
  162. OP_K:
  163. #
  164. #endif
  165.         d += p;
  166.         mem[d] = p;
  167.         mem[d+1] = c;
  168.         p = d;
  169.         c = a;
  170.         goto fetch;
  171.  
  172. #ifndef    cware
  173.     case OP_X:
  174. #ifdef    profiling
  175.         ++mininstr[d];
  176. #endif
  177. #else
  178. #asm
  179. OP_X:
  180. #
  181. #endif
  182.         switch (d)
  183.         {
  184.         case 0:
  185.         default:
  186.  
  187.             fprintf(stderr, "Bad minor opcode %d at %d\n",
  188.                 d, c - progvec - 1);
  189.             return (-1);
  190.  
  191.         case 1:
  192.             a = mem[a];
  193.             goto fetch;
  194.         case 2:
  195.             a = -a;
  196.             goto fetch;
  197.         case 3:
  198.             a = ~a;
  199.             goto fetch;
  200.         case 4:
  201.             c = mem[p+1];
  202.             p = mem[p];
  203.             goto fetch;
  204.         case 5:
  205.             a *= b;
  206.             goto fetch;
  207.         case 6:
  208.             a = b / a;
  209.             goto fetch;
  210.         case 7:
  211.             a = b % a;
  212.             goto fetch;
  213.         case 8:
  214.             a += b;
  215.             goto fetch;
  216.         case 9:
  217.             a = b - a;
  218.             goto fetch;
  219.         case 10:
  220.             a = b == a ? ~0 : 0;
  221.             goto fetch;
  222.         case 11:
  223.             a = b != a ? ~0 : 0;
  224.             goto fetch;
  225.         case 12:
  226.             a = b < a ? ~0 : 0;
  227.             goto fetch;
  228.         case 13:
  229.             a = b >= a ? ~0 : 0;
  230.             goto fetch;
  231.         case 14:
  232.             a = b > a ? ~0 : 0;
  233.             goto fetch;
  234.         case 15:
  235.             a = b <= a ? ~0 : 0;
  236.             goto fetch;
  237.         case 16:
  238.             a = b << a;
  239.             goto fetch;
  240.         case 17:
  241.             a = b >> a;
  242.             goto fetch;
  243.         case 18:
  244.             a &= b;
  245.             goto fetch;
  246.         case 19:
  247.             a |= b;
  248.             goto fetch;
  249.         case 20:
  250.             a ^= b;
  251.             goto fetch;
  252.         case 21:
  253.             a ^= ~b;
  254.             goto fetch;
  255.  
  256.         case 22:
  257.             return (0);         /* finish */
  258.  
  259.         case 23:
  260.             wp = &mem[c];
  261.             b = *wp++;
  262.             d = *wp++;    /* switchon */
  263.             while (b-- != 0)
  264.             {
  265.                 if (a == *wp++)
  266.                 {
  267.                     c = *wp++;
  268.                     goto fetch;
  269.                 }
  270.                 wp++;
  271.             }
  272.             c = d;
  273.             goto fetch;
  274.  
  275. /*
  276. // cases 24 upwards are only called from the following
  277. // hand written intcode library - iclib:
  278.  
  279. //    11 lip2 x24 x4 g11l11 /selectinput
  280. //    12 lip2 x25 x4 g12l12 /selectoutput
  281. //    13 x26 x4      g13l13 /rdch
  282. //    14 lip2 x27 x4 g14l14 /wrch
  283. //    42 lip2 x28 x4 g42l42 /findinput
  284. //    41 lip2 x29 x4 g41l41 /findoutput
  285. //    30 lip2 x30 x4 g30l30 /stop
  286. //    31 x31 x4 g31l31 /level
  287. //    32 lip3 lip2 x32 g32l32 /longjump
  288. //    46 x33 x4 g46l46 /endread
  289. //    47 x34 x4 g47l47 /endwrite
  290. //    40 lip3 lip2 x35 g40l40 /aptovec
  291. //    85 lip3 lip2 x36 x4 g85l85 / getbyte
  292. //    86 lip3 lip2 x37 x4 g86l86 / putbyte
  293. //    z
  294. */
  295.  
  296.         case 24:
  297.             slctinput(a);
  298.             goto fetch;
  299.         case 25:
  300.             slctoutput(a);
  301.             goto fetch;
  302.         case 26:
  303.             a = rdch();
  304.             goto fetch;
  305.         case 27:
  306.             wrch(a);
  307.             goto fetch;
  308.         case 28:
  309.             a = findinput(a);
  310.             goto fetch;
  311.         case 29:
  312.             a = findoutput(a);
  313.             goto fetch;
  314.         case 30:
  315.             return (a);        /* stop(a) */
  316.         case 31:
  317.             a = mem[p];
  318.             goto fetch;        /* used in level() */
  319.         case 32:
  320.             p = a;
  321.             c = b;            /* used in longjump(p,l) */
  322.             goto fetch;
  323.         case 33:
  324.             endread();
  325.             goto fetch;
  326.         case 34:
  327.             endwrite();
  328.             goto fetch;
  329.         case 35:
  330.             d = p+b+1;        /* used in aptovec(f, n) */
  331.             mem[d] = mem[p];
  332.             mem[d+1] = mem[p+1];
  333.             mem[d+2] = p;
  334.             mem[d+3] = b;
  335.             p = d;
  336.             c = a;
  337.             goto fetch;
  338.         case 36:
  339.             a = icgetbyte(a, b);    /* getbyte(s, i) */
  340.             goto fetch;
  341.         case 37:
  342.             icputbyte(a, b, mem[p+4]);    /* putbyte(s, i, ch) */
  343.             goto fetch;
  344.         }
  345.     }
  346. }
  347.